/**************************************************************************/
-static void alan_rd_init(const char* fname)
+static void alan_rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
}
}
-static void alan_wr_init(const char* fname)
+static void alan_wr_init(const QString& fname)
{
fout = gbfopen(fname, "wb", MYNAME);
}
}
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
infile = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
outfile = gbfopen_le(fname, "wb", MYNAME);
Init_Output_Type();
*/
static gbfile* fout;
-static char* filename;
static int curr_rte_num, target_rte_num;
static double radius;
static inifile_t* ini;
}
static void
-bcr_rd_init(const char* fname)
+bcr_rd_init(const QString& fname)
{
- filename = xstrdup(fname);
- ini = inifile_init(fname, MYNAME);
+ ini = inifile_init(qPrintable(fname), MYNAME);
if (ini->unicode) {
cet_convert_init(CET_CHARSET_UTF8, 1);
}
bcr_rd_deinit(void)
{
inifile_done(ini);
- xfree(filename);
}
/* ------------------------------------------------------------*/
/* %%% bcr write support %%% ----------------------------------- */
static void
-bcr_wr_init(const char* fname)
+bcr_wr_init(const QString& fname)
{
- filename = xstrdup(fname);
fout = gbfopen(fname, "wb", MYNAME);
bcr_init_radius();
}
bcr_wr_deinit(void)
{
gbfclose(fout);
- xfree(filename);
}
static void
static const int reqd_bytes[num_states] = { 6, 1, 2, 2, 25, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 1 };
-static void rd_init(const char* fname)
+static void rd_init(const QString& fname)
{
- if (serial_handle = gbser_init(fname), NULL == serial_handle) {
- fatal(MYNAME ": Can't open port '%s'\n", fname);
+ if (serial_handle = gbser_init(qPrintable(fname)), NULL == serial_handle) {
+ fatal(MYNAME ": Can't open port '%s'\n", qPrintable(fname));
}
if (gbser_set_port(serial_handle, 9600, 8, 0, 1) != gbser_OK) {
- fatal(MYNAME ": Can't configure port '%s'\n", fname);
+ fatal(MYNAME ": Can't configure port '%s'\n", qPrintable(fname));
}
}
#include "defs.h"
#include <math.h>
+#include <QtCore/QFileInfo>
#define MYNAME "Bushnell"
static gbfile* file_in;
-static char* ofname;
+static QString ofname;
static short_handle mkshort_handle = NULL;
static
}
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
- char* dot, *slash;
static char valid_chars [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789"
".-/\\~@#$%^&*()_+=<>"
"abcdefghijklmnopqrstuvwxyz";
- ofname = xstrdup(fname);
-
// If user provided an extension in the pathname, whack it.
- dot = strrchr(ofname, '.');
- slash = strrchr(ofname, GB_PATHSEP);
- if (dot > slash) {
- *dot = 0;
+ ofname = fname;
+ int suffix_len = QFileInfo(fname).suffix().length();
+ if (suffix_len > 0) {
+ /* drop the suffix and the period */
+ ofname.chop(suffix_len + 1);
}
mkshort_handle = mkshort_new_handle();
wr_deinit(void)
{
mkshort_del_handle(&mkshort_handle);
- xfree(ofname);
+ ofname.clear();
}
/*
};
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
char h[0x14]; // Believed to be zero terminated.
file_in = gbfopen_le(fname, "rb", MYNAME);
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
- int i,l = strlen(fname);
+ int i;
+ int l = fname.length();
char obuf[20] = { 0 } ;
char* p = obuf;
file_out = gbfopen_le(fname, "w", MYNAME);
trkpt_count = 0;
+ QString fnameu = fname.toUpper();
for (i = 0; (i < l) && (i < 20); i++) {
- char c = toupper(fname[i]);
+ char c = fnameu[i].toLatin1();
if (isalnum(c)) {
*p++ = c;
}
/* main functions */
static void
-compegps_rd_init(const char* fname)
+compegps_rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
input_datum = DATUM_WGS84;
/* --------------------------------------------------------------------------- */
static void
-compegps_wr_init(const char* fname)
+compegps_wr_init(const QString& fname)
{
fout = gbfopen(fname, "w", MYNAME);
sh = mkshort_new_handle();
/* --------------------------------------------------------------------------- */
static void
-cst_rd_init(const char* fname)
+cst_rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
temp_route = NULL;
extern posn_status tracking_status;
-typedef void (*ff_init)(char const*);
+typedef void (*ff_init)(const QString&);
typedef void (*ff_deinit)(void);
typedef void (*ff_read)(void);
typedef void (*ff_write)(void);
char* convert_human_time_format(const char* human_timef); /* "HH+mm+ss" -> "%H+%M+%S" */
char* pretty_deg_format(double lat, double lon, char fmt, const char* sep, int html); /* decimal -> dd.dddd or dd mm.mmm or dd mm ss */
-const char* get_filename(const char* fname); /* extract the filename portion */
+const QString get_filename(const QString& fname); /* extract the filename portion */
/*
* Character encoding transformations.
//-----------------------------------------------------------------------------
// interface to platform-specific device I/O
typedef struct {
- void (*init)(const char* name);
+ void (*init)(const QString& name);
void (*deinit)(void);
unsigned(*packet_read)(void*);
unsigned(*packet_write)(const void*, unsigned);
}
static void
-delbin_rw_init(const char* fname)
+delbin_rw_init(const QString& fname)
{
message_t m;
char buf[256];
}
message_free(&m);
- if (strlen(fname) > 4) {
- if (0 == strcmp(fname+4, "list")) {
+ if (fname.length() > 4) {
+ if (fname.mid(4,4) == "list") {
delbin_list_units();
exit(1);
}
static HANDLE hid_handle;
static void
-win_os_init(const char* fname)
+win_os_init(const QString& fname)
{
GUID hid_guid;
HDEVINFO dev_info;
}
static void
-mac_os_init(const char* fname)
+mac_os_init(const QString& fname)
{
CFMutableDictionaryRef dict = IOServiceMatching(kIOHIDDeviceKey);
io_service_t service;
static int endpoint_out;
static void
-libusb_os_init(const char* fname)
+libusb_os_init(const QString& fname)
{
struct usb_bus* bus;
const struct usb_endpoint_descriptor* endpoint_desc;
static int linuxhid_os_init_status;
static void
-linuxhid_os_init(const char* fname)
+linuxhid_os_init(const QString& fname)
{
struct hidraw_devinfo info;
struct hiddev_field_info finfo;
struct dirent* d;
fd_hidraw = fd_hiddev = -1;
- if (fname && memcmp(fname, "hid:", 4) == 0) {
- char* raw_name = xstrdup(fname + 4);
+ if (fname.startsWith("hid:")) {
+ char* raw_name = xstrdup(qPrintable(fname.mid(4)));
char* dev_name = strchr(raw_name, ',');
if (dev_name == NULL) {
fatal(MYNAME ": missing hiddev path\n");
};
static void
-linux_os_init(const char* fname)
+linux_os_init(const QString& fname)
{
// tell linuxhid_os_init not to exit
linuxhid_os_init_status = 1;
// stubs
#if !(HAVE_WDK || __APPLE__ || HAVE_LIBUSB || HAVE_LINUX_HID)
static void
-stub_os_init(const char* fname)
+stub_os_init(const QString& fname)
{
fatal(MYNAME ": OS not supported\n");
}
static gbfile* gplfile_out;
static void
-gpl_rd_init(const char* fname)
+gpl_rd_init(const QString& fname)
{
gplfile_in = gbfopen_le(fname, "rb", MYNAME);
if (sizeof(struct gpl_point) != 56) {
}
static void
-gpl_wr_init(const char* fname)
+gpl_wr_init(const QString& fname)
{
gplfile_out = gbfopen_le(fname, "wb", MYNAME);
}
*******************************************************************************/
static void
-destinator_rd_init(const char* fname)
+destinator_rd_init(const QString& fname)
{
fin = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-destinator_wr_init(const char* fname)
+destinator_wr_init(const QString& fname)
{
fout = gbfopen_le(fname, "wb", MYNAME);
}
*******************************************************************************/
static void
-common_rd_init(const char* fname)
+common_rd_init(const QString& fname)
{
- if (serial_handle = gbser_init(fname), NULL == serial_handle) {
- fatal(MYNAME ": Can't open port '%s'\n", fname);
+ if (serial_handle = gbser_init(qPrintable(fname)), NULL == serial_handle) {
+ fatal(MYNAME ": Can't open port '%s'\n", qPrintable(fname));
}
if (gbser_set_speed(serial_handle, model->speed) != gbser_OK) {
- fatal(MYNAME ": Can't configure port '%s'\n", fname);
+ fatal(MYNAME ": Can't configure port '%s'\n", qPrintable(fname));
}
// Toss anything that came in before our speed was set, particularly
// for the bluetooth BT-335 product.
}
static void
-dg100_rd_init(const char* fname)
+dg100_rd_init(const QString& fname)
{
static const model_t dg100_model = { "DG-100", 115200, 1, 1, dg100_commands, sizeof(dg100_commands) / sizeof(struct dg100_command) };
model = &dg100_model;
}
static void
-dg200_rd_init(const char* fname)
+dg200_rd_init(const QString& fname)
{
static const model_t dg200_model = { "DG-200", 230400, 0, 0, dg200_commands, sizeof(dg200_commands) / sizeof(struct dg100_command) };
model = &dg200_model;
*******************************************************************************/
static void
-dmtlog_rd_init(const char* fname)
+dmtlog_rd_init(const QString& fname)
{
fin = gbfopen_le(fname, "rb", MYNAME);
}
static void
-dmtlog_wr_init(const char* fname)
+dmtlog_wr_init(const QString& fname)
{
fout = gbfopen_le(fname, "wb", MYNAME);
}
};
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
int sz;
char ibuf[100] = {'0'} ;
if ((sz < 52) ||
strncmp(ibuf, ezsig, sizeof(ezsig)-1) ||
(ibuf[51] != 'W')) {
- fatal(MYNAME ": %s is not an EasyGPS file.\n", fname);
+ fatal(MYNAME ": %s is not an EasyGPS file.\n", qPrintable(fname));
}
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen_le(fname, "wb", MYNAME);
mkshort_handle = mkshort_new_handle();
//*******************************************************************************
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
if (global_opts.debug_level > 1) {
printf (MYNAME " rd_deinit()\n");
static gbfile* file_in, *file_out;
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen_le(fname, "wb", MYNAME);
}
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
+#include <QtCore/QFile>
#define MYNAME "exif"
const Waypoint* exif_wpt_ref;
time_t exif_time_ref;
static char exif_success;
-static char* exif_fout_name;
+static QString exif_fout_name;
static char* opt_filename, *opt_overwrite, *opt_frame, *opt_name;
*******************************************************************************/
static void
-exif_rd_init(const char* fname)
+exif_rd_init(const QString& fname)
{
fin = gbfopen_be(fname, "rb", MYNAME);
QUEUE_INIT(&exif_apps);
}
static void
-exif_wr_init(const char* fname)
+exif_wr_init(const QString& fname)
{
uint16_t soi;
exif_success = 0;
- exif_fout_name = xstrdup(fname);
+ exif_fout_name = fname;
QUEUE_INIT(&exif_apps);
static void
exif_wr_deinit(void)
{
- char* tmpname;
exif_release_apps();
- tmpname = xstrdup(fout->name);
+ QString tmpname = QString::fromLocal8Bit(fout->name);
gbfclose(fout);
if (exif_success) {
if (*opt_overwrite == '1') {
- remove(exif_fout_name);
- rename(tmpname, exif_fout_name);
+ QFile::remove(exif_fout_name);
+ QFile::rename(tmpname, exif_fout_name);
}
} else {
- remove(tmpname);
+ QFile::remove(tmpname);
}
- xfree(exif_fout_name);
- xfree(tmpname);
+ exif_fout_name.clear();
}
static void
*******************************************************************************/
#define VALIDHEADER "MEDIA 1."
static void
-f90g_track_rd_init(const char* fname)
+f90g_track_rd_init(const QString& fname)
{
char header[HEADERRECORDSIZE];
// start the track list
track = route_head_alloc();
is_fatal((track == NULL), MYNAME ": memory non-enough");
- track->rte_name = QString::fromLatin1(fname);
+ track->rte_name = fname;
track_add_head(track);
}
}
/* main functions */
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
static void
-rw_init(const char* fname)
+rw_init(const QString& fname)
{
int receiver_short_length;
int receiver_must_upper = 1;
GPS_Enable_Error();
if (poweroff) {
- GPS_Command_Off(fname);
+ GPS_Command_Off(qPrintable(fname));
return;
}
* an affected unit.
*/
if (resettime) {
- GPS_Command_Send_Time(fname, current_time().toTime_t());
+ GPS_Command_Send_Time(qPrintable(fname), current_time().toTime_t());
return;
}
}
}
- if (GPS_Init(fname) < 0) {
- fatal(MYNAME ":Can't init %s\n", fname);
+ if (GPS_Init(qPrintable(fname)) < 0) {
+ fatal(MYNAME ":Can't init %s\n", qPrintable(fname));
}
- portname = fname;
+ portname = xstrdup(qPrintable(fname));
if (baud && baud != DEFAULT_BAUD) {
if (0 == GPS_Set_Baud_Rate(portname, baud)) {
}
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
if (setjmp(gdx_jmp_buf)) {
const char* vec_opts = NULL;
if (mkshort_handle) {
mkshort_del_handle(&mkshort_handle);
}
+
+ xfree(portname);
+ portname = NULL;
}
static int
static gpsdevh* pvt_fd;
static void
-pvt_init(const char* fname)
+pvt_init(const QString& fname)
{
rw_init(fname);
- GPS_Command_Pvt_On(fname, &pvt_fd);
+ GPS_Command_Pvt_On(qPrintable(fname), &pvt_fd);
}
static Waypoint*
*******************************************************************************/
static void
-fit_rd_init(const char* fname)
+fit_rd_init(const QString& fname)
{
fin = gbfopen_le(fname, "rb", MYNAME);
}
*******************************************************************************/
static void
-garmin_gpi_rd_init(const char* fname)
+garmin_gpi_rd_init(const QString& fname)
{
fin = gbfopen_le(fname, "rb", MYNAME);
rdata = new reader_data_t;
static void
-garmin_gpi_wr_init(const char* fname)
+garmin_gpi_wr_init(const QString& fname)
{
int i;
*******************************************************************************/
static void
-garmin_txt_wr_init(const char* fname)
+garmin_txt_wr_init(const QString& fname)
{
const char* grid_str;
/***************************************************************/
static void
-garmin_txt_rd_init(const char* fname)
+garmin_txt_rd_init(const QString& fname)
{
memset(>xt_flags, 0, sizeof(gtxt_flags));
* %%% Reader callbacks %%% *
*******************************************************************************/
static void
-format_garmin_xt_rd_init(const char* fname)
+format_garmin_xt_rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
}
file->fileungetc = memapi_ungetc;
file->filewrite = memapi_write;
} else {
- file->name = xstrdup(filename);
+ /* Be careful to convert back to local8Bit for these c based APIS */
+ file->name = xstrdup(qPrintable(filename));
file->is_pipe = (filename == "-");
/* Do we have a '.gz' extension in the filename ? */
/*******************************************************************************/
static void
-gdb_rd_init(const char* fname)
+gdb_rd_init(const QString& fname)
{
fin = gbfopen_le(fname, "rb", MYNAME);
ftmp = gbfopen_le(NULL, "wb", MYNAME);
/*-----------------------------------------------------------------------------*/
static void
-gdb_wr_init(const char* fname)
+gdb_wr_init(const QString& fname)
{
fout = gbfopen_le(fname, "wb", MYNAME);
ftmp = gbfopen_le(NULL, "wb", MYNAME);
}
static void
-geo_rd_init(const char* fname)
+geo_rd_init(const QString& fname)
{
geo_read_fname = fname;
}
}
static void
-geo_wr_init(const char* fname)
+geo_wr_init(const QString& fname)
{
ofd = gbfopen(fname, "w", MYNAME);
}
static void
-ggv_bin_read_init(const char* fname)
+ggv_bin_read_init(const QString& fname)
{
- read_fname = QString::fromUtf8(fname);
+ read_fname = fname;
}
static void
ggv_bin_read_deinit(void)
{
+ read_fname.clear();
}
static void
QFile file(read_fname);
if (!file.open(QIODevice::ReadOnly)) {
- fatal(MYNAME ": Error opening file %s\n", read_fname.toStdString().c_str());
+ fatal(MYNAME ": Error opening file %s\n", qPrintable(read_fname));
}
QDataStream stream(&file);
*******************************************************************************/
static void
-ggv_log_rd_init(const char* fname)
+ggv_log_rd_init(const QString& fname)
{
static char magic[32];
int len = 0;
}
static void
-ggv_log_wr_init(const char* fname)
+ggv_log_wr_init(const QString& fname)
{
fout = gbfopen(fname, "wb", MYNAME);
*******************************************************************************/
static void
-ggv_ovl_rd_init(const char* fname)
+ggv_ovl_rd_init(const QString& fname)
{
- inifile = inifile_init(fname, MYNAME);
+ inifile = inifile_init(qPrintable(fname), MYNAME);
if (inifile->unicode) {
cet_convert_init(CET_CHARSET_UTF8, 1);
}
/* -----------------------------------------------------------------------*/
static void
-ggv_ovl_wr_init(const char* fname)
+ggv_ovl_wr_init(const QString& fname)
{
fout = gbfopen(fname, "w", MYNAME);
}
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
if (global_opts.debug_level > 1) {
printf(MYNAME " rd_init()\n");
}
}
if (!opt_input_dump_file) {
- serial_init(fname);
+ serial_init(qPrintable(fname));
} else {
// read from dump-file instead of serial
in_file = gbfopen(fname, "r", MYNAME);
- is_fatal(!in_file, "Could not open dumpfile for input: %s", fname);
+ is_fatal(!in_file, "Could not open dumpfile for input: %s", qPrintable(fname));
}
globalsat_probe_device();
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
if (global_opts.debug_level > 1) {
printf(MYNAME " wr_init()\n");
}
- serial_init(fname);
+ serial_init(qPrintable(fname));
}
};
static void
-glogbook_rd_init(const char* fname)
+glogbook_rd_init(const QString& fname)
{
xml_init(fname, gl_map, NULL);
}
}
static void
-glogbook_wr_init(const char* fname)
+glogbook_wr_init(const QString& fname)
{
ofd = gbfopen(fname, "w", MYNAME);
writer.setAutoFormatting(true);
*******************************************************************************/
static void
-gnav_trl_rd_init(const char* fname)
+gnav_trl_rd_init(const QString& fname)
{
fin = gbfopen_le(fname, "rb", MYNAME);
}
static void
-gnav_trl_rw_init(const char* fname)
+gnav_trl_rw_init(const QString& fname)
{
fout = gbfopen_le(fname, "wb", MYNAME);
}
static route_head** routehead;
static int* routecount;
static short_handle desc_handle;
-static const char* rd_fname;
+static QString rd_fname;
static int serial = 0;
}
static void
-google_rd_init(const char* fname)
+google_rd_init(const QString& fname)
{
rd_fname = fname;
static void
goog_read_file(void)
{
- QFile src(QString::fromUtf8(rd_fname));
+ QFile src(rd_fname);
src.open(QIODevice::ReadOnly);
{
xml_deinit();
mkshort_del_handle(&desc_handle);
+ rd_fname.clear();
}
ff_vecs_t google_vecs = {
}
static void
-google_rd_init(const char* fname)
+google_rd_init(const QString& fname)
{
desc_handle = mkshort_new_handle();
setshort_length(desc_handle, 12);
*******************************************************************************/
static void
-gopal_rd_init(const char* fname)
+gopal_rd_init(const QString& fname)
{
- char buff[32];
char* ck;
- const char* filename;
CHECK_BOOL(optclean);
if (optminspeed) {
minspeed=atof(optminspeed);
fin = gbfopen(fname, "r", MYNAME);
- memset(buff,0,sizeof(buff));
if (optdate) {
memset(&opt_tm, 0, sizeof(opt_tm));
} else {
/* remove path */
- filename = get_filename(fname);
+ QString filename = get_filename(fname);
+ QString datestr;
- if ((strncmp(filename,"track",5)==0)&&(strlen(filename)>13)) { // we need at least 13 letters: trackYYYYMMDD...
- strncpy(&buff[0],&filename[5],8);
- } else if ((strncmp(filename,"A_",2)==0)&&(strlen(filename)>10)) { // here we expect at least 10 letters: A_YYYYMMDD...
- strncpy(&buff[0],&filename[2],8);
+ if (filename.startsWith("track")&&(filename.length()>13)) { // we need at least 13 letters: trackYYYYMMDD...
+ datestr = filename.mid(5,8);
+ } else if (filename.startsWith("A_")&&(filename.length()>10)) { // here we expect at least 10 letters: A_YYYYMMDD...
+ datestr = filename.mid(2,8);
}
// in buff we should now have something wich looks like a valid date starting with YYYYMMDD
- /*ck = (char*)*/strptime(buff, "%Y%m%d", &filenamedate);
+ /*ck = (char*)*/strptime(qPrintable(datestr), "%Y%m%d", &filenamedate);
// if (((ck == NULL) || (*ck != '\0') )&&!(optdate))
// fatal(MYNAME ": Invalid date in filename \"%s\", try to set manually using \"date\" switch!\n", buff);
// /* else */ if (filenamedate.tm_year < 70)
static void
-gopal_wr_init(const char* fname)
+gopal_wr_init(const QString& fname)
{
fout = gbfopen(fname, "w", MYNAME);
}
static char* wayptspd;
static char* splitfiles_opt;
static int splitfiles;
-static char* fnamestr;
+static QString fnamestr;
static int trk_count;
static int doing_tracks;
*/
static void
-gpssim_wr_init(const char* fname)
+gpssim_wr_init(const QString& fname)
{
- fnamestr = xstrdup(fname);
+ fnamestr = fname;
trk_count = 0;
splitfiles = splitfiles_opt ? atoi(splitfiles_opt) : 0;
fout = NULL;
}
- xfree(fnamestr);
+ fnamestr.clear();
}
gpssim_trk_hdr(const route_head* rh)
{
if (splitfiles) {
- char c[1024];
- char* ofname = xstrdup(fnamestr);
if (fout) {
fatal(MYNAME ": output file already open.\n");
}
- snprintf(c, sizeof(c), "%s%04d.gpssim",
- doing_tracks ? "-track" : "-route",
- trk_count++);
- ofname = xstrappend(ofname, c);
+ QString ofname = QString("%1%2%3.gpssim").arg(fnamestr).arg(doing_tracks ? "-track" : "-route").arg(trk_count++, 4, 10, QChar('0'));
fout = gbfopen(ofname, "wb", MYNAME);
- xfree(ofname);
}
track_recompute(rh, NULL);
}
{
if (waypt_count()) {
if (splitfiles) {
- char* ofname = xstrdup(fnamestr);
- ofname = xstrappend(ofname, "-waypoints.gpssim");
+ QString ofname = fnamestr + "-waypoints.gpssim";
fout = gbfopen(ofname, "wb", MYNAME);
- xfree(ofname);
}
if (wayptspd && wayptspd[0]) {
gpssim_write_spd(atof(wayptspd));
#define MYNAME "GPSUTIL"
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen(fname, "w", MYNAME);
mkshort_handle = mkshort_new_handle();
}
static void
-gpx_rd_init(const char* fname)
+gpx_rd_init(const QString& fname)
{
iqfile = new gpsbabel::File(fname);
iqfile->open(QIODevice::ReadOnly);
}
static void
-gpx_wr_init(const char* fname)
+gpx_wr_init(const QString& fname)
{
mkshort_handle = NULL;
oqfile = new gpsbabel::File(fname);
/* Callbacks */
static void
-gtm_rd_init(const char* fname)
+gtm_rd_init(const QString& fname)
{
int version;
file_in = gbfopen_le(fname, "rb", MYNAME);
}
static void
-gtm_wr_init(const char* fname)
+gtm_wr_init(const QString& fname)
{
rt_count = tr_count = 0;
track_disp_all(NULL, NULL, count_track_waypts);
};
static void
-gtc_rd_init(const char* fname)
+gtc_rd_init(const QString& fname)
{
xml_init(fname, gtc_map, NULL);
xml_ignore_tags(gtc_tags_to_ignore);
}
static void
-gtc_wr_init(const char* fname)
+gtc_wr_init(const QString& fname)
{
int i;
};
static void
-hiketech_rd_init(const char* fname)
+hiketech_rd_init(const QString& fname)
{
xml_init(fname, ht_map, NULL);
}
}
static void
-hiketech_wr_init(const char* fname)
+hiketech_wr_init(const QString& fname)
{
ofd = gbfopen(fname, "w", MYNAME);
#define MYNAME "Holux"
-static void rd_init(const char* fname)
+static void rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "rb", MYNAME);
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
mkshort_handle = mkshort_new_handle();
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen(fname, "w", MYNAME);
mkshort_handle = mkshort_new_handle();
*******************************************************************************/
static void
-humminbird_rd_init(const char* fname)
+humminbird_rd_init(const QString& fname)
{
fin = gbfopen_be(fname, "rb", MYNAME);
}
/************************************************************************************************/
static void
-humminbird_wr_init(const char* fname)
+humminbird_wr_init(const QString& fname)
{
fout = gbfopen_be(fname, "wb", MYNAME);
return (igc_rec_type_t) c[0];
}
-static void rd_init(const char* fname)
+static void rd_init(const QString& fname)
{
char* ibuf;
lineno = 0;
// File must begin with a manufacturer/ID record
if (get_record(&ibuf) != rec_manuf_id || sscanf(ibuf, "A%3[A-Z]", manufacturer) != 1) {
- fatal(MYNAME ": %s is not an IGC file\n", fname);
+ fatal(MYNAME ": %s is not an IGC file\n", qPrintable(fname));
}
}
}
}
-static void wr_init(const char* fname)
+static void wr_init(const QString& fname)
{
file_out = gbfopen(fname, "wb", MYNAME);
}
/* callbacks registered in ignr_vecs */
static void
-ignr_rd_init(const char* fname)
+ignr_rd_init(const QString& fname)
{
xml_init(fname, ignr_xml_map, NULL);
wpt = NULL;
/* callbacks registered in ignr_vecs */
static void
-ignr_rw_init(const char* fname)
+ignr_rw_init(const QString& fname)
{
fout = gbfopen(fname, "w", MYNAME);
}
}
// Reader initialization callback
-static void igo8_read_init(const char* fname)
+static void igo8_read_init(const QString& fname)
{
igo8_file_in = gbfopen_le(fname, "rb", MYNAME);
}
// Writer initialize callback
-static void igo8_write_init(const char* fname)
+static void igo8_write_init(const QString& fname)
{
igo8_file_out = gbfopen_le(fname, "wb", MYNAME);
}
static void
-ikt_rd_init(const char* fname)
+ikt_rd_init(const QString& fname)
{
xml_init(fname, ikt_map, NULL);
*******************************************************************************/
static void
-itracku_rd_init_common(const char* fname)
+itracku_rd_init_common(const QString& fname)
{
new_waypoint_count = 0;
}
static void
-itracku_rd_ser_init(const char* fname)
+itracku_rd_ser_init(const QString& fname)
{
#if LATER
int i;
- if (0 == strcmp(fname, port_auto_detect_filename)) {
+ if (0 == strcmp(qPrintable(fname), port_auto_detect_filename)) {
dbg(1, "auto detecting port for iTrackU device");
for (i=1; !fd && i<port_auto_detect_max_port; ++i) {
xasprintf(&port, "com%d", i);
#endif
{
- if (gbser_is_serial(fname)) {
- port = xstrdup(fname);
+ if (gbser_is_serial(qPrintable(fname))) {
+ port = xstrdup(qPrintable(fname));
- dbg(1, "opening port %s", fname);
+ dbg(1, "opening port %s", qPrintable(fname));
if ((fd = gbser_init(port)) == NULL) {
fatal(MYNAME ": can't initialise port \"%s\"", port);
}
fatal(MYNAME ": can't initialise device on port \"%s\"", port);
}
} else {
- fatal(MYNAME ": \"%s\" is not a valid serial port", fname);
+ fatal(MYNAME ": \"%s\" is not a valid serial port", qPrintable(fname));
}
}
}
static void
-itracku_rd_init(const char* fname)
+itracku_rd_init(const QString& fname)
{
fin = gbfopen(fname, "r", MYNAME);
itracku_rd_init_common(fname);
}
static void
-itracku_wr_init(const char* fname)
+itracku_wr_init(const QString& fname)
{
fout = gbfopen(fname, "w", MYNAME);
}
}
static void
-itracku_rt_init(const char* fname)
+itracku_rt_init(const QString& fname)
{
itracku_rd_ser_init(fname);
itracku_device_write_string("WP AP-Exit");
};
static void
-jogmap_rd_init(const char* fname)
+jogmap_rd_init(const QString& fname)
{
trk = NULL;
xml_init(fname, jogmap_map, NULL);
*******************************************************************************/
static void
-jtr_rd_init(const char* fname)
+jtr_rd_init(const QString& fname)
{
fin = gbfopen(fname, "r", MYNAME);
}
}
static void
-jtr_wr_init(const char* fname)
+jtr_wr_init(const QString& fname)
{
fout = gbfopen(fname, "wb", MYNAME);
}
static Waypoint* wpt_tmp;
static int wpt_tmp_queued;
-static const char* posnfilename;
-static char* posnfilenametmp;
+static QString posnfilename;
+static QString posnfilenametmp;
static route_head* gx_trk_head;
static QList<gpsbabel::DateTime>* gx_trk_times;
static
void
-kml_rd_init(const char* fname)
+kml_rd_init(const QString& fname)
{
xml_init(fname, kml_map, NULL);
xml_ignore_tags(kml_tags_to_ignore);
}
static void
-kml_wr_init(const char* fname)
+kml_wr_init(const QString& fname)
{
char u = 's';
waypt_init_bounds(&kml_bounds);
* updated.
*/
static void
-kml_wr_position_init(const char* fname)
+kml_wr_position_init(const QString& fname)
{
posnfilename = fname;
- posnfilenametmp = xstrappend(xstrdup(fname), "-");
+ posnfilenametmp = QString("%1-").arg(fname);
realtime_positioning = 1;
/*
delete oqfile;
oqfile = NULL;
- if (posnfilenametmp) {
+ if (!posnfilenametmp.isEmpty()) {
#if __WIN32__
- MoveFileExA(posnfilenametmp, posnfilename,
+ MoveFileExA(qPrintable(posnfilenametmp), qPrintable(posnfilename),
MOVEFILE_REPLACE_EXISTING);
#endif
- rename(posnfilenametmp, posnfilename);
+ QFile::rename(posnfilenametmp, posnfilename);
}
}
kml_wr_position_deinit(void)
{
// kml_wr_deinit();
- if (posnfilenametmp) {
- xfree(posnfilenametmp);
- posnfilenametmp = NULL;
- }
+ posnfilename.clear();
+ posnfilenametmp.clear();
}
static void
-lmx_wr_init(const char* fname)
+lmx_wr_init(const QString& fname)
{
ofd = gbfopen(fname, "w", MYNAME);
}
};
static void
-lmx_rd_init(const char* fname)
+lmx_rd_init(const QString& fname)
{
xml_init(fname, gl_map, NULL);
}
};
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen_le(fname, "wb", MYNAME);
mkshort_handle = mkshort_new_handle();
};
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen_le(fname, "wb", MYNAME);
mkshort_handle = mkshort_new_handle();
}
static void
-maggeo_rd_init(const char* fname)
+maggeo_rd_init(const QString& fname)
{
maggeofile_in = gbfopen(fname, "rb", MYNAME);
}
}
static void
-maggeo_wr_init(const char* fname)
+maggeo_wr_init(const QString& fname)
{
if (waypt_count() > 200) {
fatal(MYNAME ": eXplorist does not support more than 200 waypoints in one .gs file.\nDecrease the number of waypoints sent.\n");
#include <stdio.h>
#include <math.h>
#include <time.h>
+#include <QtCore/QFileInfo>
static int bitrate = 4800;
static int wptcmtcnt;
static int route_out_count;
static int waypoint_read_count;
static int wpt_len = 8;
-static const char* curfname;
+static QString curfname;
static int extension_hint;
// For Explorist GC/510/610/710 familes, bludgeon in GPX support.
// (This has nothing to do with the Explorist 100...600 products.)
static void* serial_handle = NULL;
static int
-terminit(const char* portname, int create_ok)
+terminit(const QString& portname, int create_ok)
{
- if (gbser_is_serial(portname)) {
- if (serial_handle = gbser_init(portname), NULL != serial_handle) {
+ if (gbser_is_serial(qPrintable(portname))) {
+ if (serial_handle = gbser_init(qPrintable(portname)), NULL != serial_handle) {
int rc;
if (rc = gbser_set_port(serial_handle, bitrate, 8, 0, 1), gbser_OK != rc) {
fatal(MYNAME ": Can't configure port\n");
}
is_file = 0;
if (serial_handle == NULL) {
- fatal(MYNAME ": Could not open serial port %s\n", portname);
+ fatal(MYNAME ": Could not open serial port %s\n", qPrintable(portname));
}
return 1;
} else {
* The part of the serial init that's common to read and write.
*/
static void
-mag_serial_init_common(const char* portname)
+mag_serial_init_common(const QString& portname)
{
time_t now, later;
mag_readmsg(trkdata);
if (current_time().toTime_t() > later) {
fatal(MYNAME ": No acknowledgment from GPS on %s\n",
- portname);
+ qPrintable(portname));
}
}
}
static void
-mag_rd_init_common(const char* portname)
+mag_rd_init_common(const QString& portname)
{
- const char* ext;
waypoint_read_count = 0;
// For Explorist GC, intercept the device access and redirect to GPX.
// We actually do the rd_init() inside read as we may have multiple
// files that we have to read.
- if (0 == strcmp(portname, "usb:")) {
+ if (portname == "usb:") {
const char** dlist = os_get_magellan_mountpoints();
explorist_info = explorist_ini_get(dlist);
if (explorist_info) {
* queue or the WPT queue in the presence of (-w -r -t) we
* divine a hint from the filename extension when we can.
*/
- ext = strrchr(curfname, '.');
- if (ext) {
- ext++;
- if (0 == case_ignore_strcmp(ext, "upt")) {
+ QString exten = QFileInfo(curfname).suffix();
+ if (exten.length() > 0) {
+ if (0 == exten.compare("upt", Qt::CaseInsensitive)) {
extension_hint = WPTDATAMASK;
- } else if (0 == case_ignore_strcmp(ext, "log")) {
+ } else if (0 == exten.compare("log", Qt::CaseInsensitive)) {
extension_hint = TRKDATAMASK;
- } else if (0 == case_ignore_strcmp(ext, "rte")) {
+ } else if (0 == exten.compare("rte", Qt::CaseInsensitive)) {
extension_hint = RTEDATAMASK;
}
}
}
static void
-mag_rd_init(const char* portname)
+mag_rd_init(const QString& portname)
{
explorist = 0;
suppress_ack = 1;
}
static void
-magX_rd_init(const char* portname)
+magX_rd_init(const QString& portname)
{
explorist = 1;
mag_rd_init_common(portname);
}
static void
-mag_wr_init_common(const char* portname)
+mag_wr_init_common(const QString& portname)
{
suppress_ack = 0;
if (bs) {
* Entry point for extended (explorist) points.
*/
static void
-magX_wr_init(const char* portname)
+magX_wr_init(const QString& portname)
{
wpt_len = 20;
explorist = 1;
}
static void
-mag_wr_init(const char* portname)
+mag_wr_init(const QString& portname)
{
explorist = 0;
wpt_len = 8;
waypt_flush(&rte_wpt_tmp);
trk_head = NULL;
+
+ curfname.clear();
}
static void
*/
#include <QtCore/QTextCodec>
+#include <QtCore/QCoreApplication>
#include "defs.h"
#include "filterdefs.h"
queue* wpt_head_bak, *rte_head_bak, *trk_head_bak; /* #ifdef UTF8_SUPPORT */
signed int wpt_ct_bak, rte_ct_bak, trk_ct_bak; /* #ifdef UTF8_SUPPORT */
arg_stack_t* arg_stack = NULL;
+
+ // Create a QCoreApplication object to handle application initialization.
+ // TODO: Someday we may actually use this, but for now we are just trying
+ // to get Qt initialized, especially locale related QTextCodec stuff.
+ // For example, this will get the QTextCodec::codecForLocale set
+ // correctly.
+ QCoreApplication app(argc, argv);
+ // TODO: use QCoreApplication::arguments() to process command line.
+
(void) new gpsbabel::UsAsciiCodec(); /* make sure a US-ASCII codec is available */
#if (QT_VERSION < QT_VERSION_CHECK(5, 0, 0))
// The first invocation of QTextCodec::codecForLocale() may result in LC_ALL being set to the native environment
// as opposed to the initial default "C" locale.
// This was demonstrated with Qt5 on Mac OS X.
+ // TODO: This need to invoke QTextCodec::codecForLocale() may be taken care of
+ // by creating a QCoreApplication.
#ifdef DEBUG_LOCALE
- printf("%s\n",setlocale(LC_ALL, NULL));
+ printf("Initial locale: %s\n",setlocale(LC_ALL, NULL));
#endif
(void) QTextCodec::codecForLocale();
#ifdef DEBUG_LOCALE
- printf("%s\n",setlocale(LC_ALL, NULL));
+ printf("Locale after codedForLocale: %s\n",setlocale(LC_ALL, NULL));
#endif
// As recommended in QCoreApplication reset the locale to the default.
// Note the documentation says to set LC_NUMERIC, but QCoreApplicationPrivate::initLocale()
#endif
setlocale(LC_NUMERIC,"C");
#ifdef DEBUG_LOCALE
- printf("%s\n",setlocale(LC_ALL, NULL));
+ printf("LC_ALL: %s\n",setlocale(LC_ALL, NULL));
+#endif
+ }
+ /* reset LC_TIME for strftime */
+ if (strcmp(setlocale(LC_TIME,0), "C") != 0) {
+#ifdef DEBUG_LOCALE
+ printf("Resetting LC_TIME\n");
+#endif
+ setlocale(LC_TIME,"C");
+#ifdef DEBUG_LOCALE
+ printf("LC_ALL: %s\n",setlocale(LC_ALL, NULL));
#endif
}
cet_convert_init(ivecs->encode, ivecs->fixed_encode); /* init by module vec */
start_session(ivecs->name, fname);
- ivecs->rd_init(fname);
+ ivecs->rd_init(QString::fromLocal8Bit(fname));
ivecs->read();
ivecs->rd_deinit();
trk_ct_bak = -1;
rte_head_bak = trk_head_bak = NULL;
- ovecs->wr_init(ofname);
+ ovecs->wr_init(QString::fromLocal8Bit(ofname));
if (global_opts.charset != &cet_cs_vec_utf8) {
/*
if (ivecs->rd_init == NULL) {
fatal("Format does not support reading.\n");
}
- ivecs->rd_init(argv[0]);
+ ivecs->rd_init(QString::fromLocal8Bit(argv[0]));
ivecs->read();
ivecs->rd_deinit();
fatal("Format does not support writing.\n");
}
- ovecs->wr_init(argv[1]);
+ ovecs->wr_init(QString::fromLocal8Bit(argv[1]));
ovecs->write();
ovecs->wr_deinit();
fatal("An input file (-f) must be specified.\n");
}
start_session(ivecs->name, fname);
- ivecs->position_ops.rd_init(fname);
+ ivecs->position_ops.rd_init(QString::fromLocal8Bit(fname));
}
if (global_opts.masked_objective & ~POSNDATAMASK) {
}
if (ovecs && ovecs->position_ops.wr_init) {
- ovecs->position_ops.wr_init(ofname);
+ ovecs->position_ops.wr_init(QString::fromLocal8Bit(ofname));
}
tracking_status.request_terminate = 0;
}
if (wpt) {
if (ovecs) {
-// ovecs->position_ops.wr_init(ofname);
+// ovecs->position_ops.wr_init(QString::fromLocal8Bit(ofname));
ovecs->position_ops.wr_position(wpt);
// ovecs->position_ops.wr_deinit();
} else {
*******************************************************************************/
static void
-tr7_rd_init(const char* fname)
+tr7_rd_init(const QString& fname)
{
fin = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-tr7_wr_init(const char* fname)
+tr7_wr_init(const QString& fname)
{
fout = gbfopen_le(fname, "wb", MYNAME);
gbfputint32(TR7_TRACK_MAGIC, fout);
*******************************************************************************/
static void
-mapbar_track_rd_init(const char* fname)
+mapbar_track_rd_init(const QString& fname)
{
fin = gbfopen(fname, "r", MYNAME);
}
}
static void
-mapfactor_rd_init(const char* fname)
+mapfactor_rd_init(const QString& fname)
{
mapfactor_read_fname = fname;
}
}
static void
-mapfactor_wr_init(const char* fname)
+mapfactor_wr_init(const QString& fname)
{
oqfile = new gpsbabel::File(fname);
oqfile->open(QIODevice::WriteOnly | QIODevice::Text);
}
static void
-mapsend_rd_init(const char* fname)
+mapsend_rd_init(const QString& fname)
{
mapsend_init_opts(1);
mapsend_file_in = gbfopen_le(fname, "rb", MYNAME);
}
static void
-mapsend_wr_init(const char* fname)
+mapsend_wr_init(const QString& fname)
{
mapsend_init_opts(0);
mapsend_file_out = gbfopen(fname, "wb", MYNAME);
#include "jeeps/gpsmath.h"
#include <stdio.h>
#include <stdlib.h>
+#include <QtCore/QFile>
static gbfile* mps_file_in;
static gbfile* mps_file_out;
static int mps_ver_temp = 0;
/* Temporary pathname used when merging gpsbabel output with an existing file */
-static char* tempname;
-static char* fin_name;
+static QString tempname;
+static QString fin_name;
static const Waypoint* prevRouteWpt;
/* Private queues of written out waypoints */
}
static void
-mps_rd_init(const char* fname)
+mps_rd_init(const QString& fname)
{
mps_file_in = gbfopen_le(fname, "rb", MYNAME);
}
static void
-mps_wr_init(const char* fname)
+mps_wr_init(const QString& fname)
{
- fin_name = xstrdup(fname);
+ fin_name = fname;
if (mpsmergeouts) {
mpsmergeout = atoi(mpsmergeouts);
}
/* create a temporary name based on a random char and the existing name */
/* then test if it already exists, if so try again with another rand num */
/* yeah, yeah, so there's probably a library function for this */
- xasprintf(&tempname, "%s.%08x", fname, rand());
+ tempname = QString("%1.%2").arg(fname).arg(rand(), 8, 16, QChar('0'));
mps_file_temp = gbfopen_le(tempname, "rb", MYNAME);
if (mps_file_temp == NULL) {
break;
}
gbfclose(mps_file_temp);
}
- rename(fname, tempname);
+ QFile::rename(fname, tempname);
mps_file_temp = gbfopen_le(tempname, "rb", MYNAME);
}
}
if (mpsmergeout) {
gbfclose(mps_file_temp);
- remove(tempname);
- xfree(tempname);
+ QFile::remove(tempname);
+ tempname.clear();
}
if (written_wpt_mkshort_handle) {
/* flush the "private" queue of waypoints written */
mps_wpt_q_deinit(&written_wpt_head);
mps_wpt_q_deinit(&written_route_wpt_head);
- xfree(fin_name);
+ fin_name.clear();
}
/*
/* then delete the "real" file and rename the temporarily renamed file back */
gbfclose(mps_file_temp);
gbfclose(mps_file_out);
- remove(fin_name);
- rename(tempname, fin_name);
+ QFile::remove(fin_name);
+ QFile::rename(tempname, fin_name);
fatal(MYNAME ": merge source version is %d, requested out version is %d\n", mps_ver_temp, atoi(mpsverout));
}
} else {
*******************************************************************************/
static void
-mmo_rd_init(const char* fname)
+mmo_rd_init(const QString& fname)
{
int i;
/**************************************************************************/
static void
-mmo_wr_init(const char* fname)
+mmo_wr_init(const QString& fname)
{
fout = gbfopen_le(fname, "wb", MYNAME);
ARG_TERMINATOR
};
-static void mtk_locus_rd_init(const char* fname);
+static void mtk_locus_rd_init(const QString& fname);
static void mtk_locus_rd_deinit(void);
static void mtk_locus_read(void);
static void dbg(int l, const char* msg, ...);
static void
-mtk_locus_rd_init(const char* fname)
+mtk_locus_rd_init(const QString& fname)
{
- dbg(1, "Opening file: %s\n", fname);
+ dbg(1, "Opening file: %s\n", qPrintable(fname));
- if (gbser_is_serial(fname)) {
+ if (gbser_is_serial(qPrintable(fname))) {
dbg(1, "Input is a serial port\n");
read_mode = rm_serial;
- if ((sfd = gbser_init(fname)) == NULL) {
- fatal(MYNAME ": Can't initialise port \"%s\" (%s)\n", fname, strerror(errno));
+ if ((sfd = gbser_init(qPrintable(fname))) == NULL) {
+ fatal(MYNAME ": Can't initialise port \"%s\" (%s)\n", qPrintable(fname), strerror(errno));
}
set_baudrate();
gbser_flush(sfd);
dbg(1, "Input is a normal file\n");
read_mode = rm_file;
if ((ffd = gbfopen(fname, "rb", MYNAME)) == NULL) {
- fatal(MYNAME ": Can't initialise port \"%s\" (%s)\n", fname, strerror(errno));
+ fatal(MYNAME ": Can't initialise port \"%s\" (%s)\n", qPrintable(fname), strerror(errno));
}
}
const char CMD_LOG_STATUS[] = "$PMTK182,2,7*3C\r\n";
static int mtk_log_len(unsigned int bitmask);
-static void mtk_rd_init(const char* fname);
-static void file_init(const char* fname);
+static void mtk_rd_init(const QString& fname);
+static void file_init(const QString& fname);
static void file_deinit(void) ;
static void holux245_init(void);
static void file_read(void);
/*******************************************************************************
* %%% global callbacks called by gpsbabel main process %%% *
*******************************************************************************/
-static void mtk_rd_init_m241(const char* fname)
+static void mtk_rd_init_m241(const QString& fname)
{
mtk_device = HOLUX_M241;
mtk_rd_init(fname);
}
-static void mtk_rd_init(const char* fname)
+static void mtk_rd_init(const QString& fname)
{
int rc;
char* model;
- port = xstrdup(fname);
+ port = xstrdup(qPrintable(fname));
errno = 0;
- dbg(1, "Opening port %s...\n", fname);
+ dbg(1, "Opening port %s...\n", port);
if ((fd = gbser_init(port)) == NULL) {
fatal(MYNAME ": Can't initialise port \"%s\" (%s)\n", port, strerror(errno));
}
/********************** File-in interface ********************************/
-static void file_init_m241(const char* fname)
+static void file_init_m241(const QString& fname)
{
mtk_device = HOLUX_M241;
file_init(fname);
}
-static void file_init(const char* fname)
+static void file_init(const QString& fname)
{
- dbg(4, "Opening file %s...\n", fname);
- if (fl = fopen(fname, "rb"), NULL == fl) {
- fatal(MYNAME ": Can't open file '%s'\n", fname);
+ dbg(4, "Opening file %s...\n", qPrintable(fname));
+ if (fl = fopen(qPrintable(fname), "rb"), NULL == fl) {
+ fatal(MYNAME ": Can't open file '%s'\n", qPrintable(fname));
}
switch (mtk_device) {
case HOLUX_M241:
//***************************************************************************
static void
-mynav_rd_init(const char* fname)
+mynav_rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
mynav_track = route_head_alloc();
#include "src/core/file.h"
static char* noretired = NULL;
-static const char* read_fname = NULL;
+static QString read_fname;
static
arglist_t nav_args[] = {
}
static void
-nav_rd_init(const char* fname)
+nav_rd_init(const QString& fname)
{
read_fname = fname;
}
}
static void
-nav_wr_init(const char* fname)
+nav_wr_init(const QString& fname)
{
fatal(MYNAME ": Does not support writing Navicache files.\n");
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen_le(fname, "wb", MYNAME);
ng_fill_header_default();
/*=========================== Read data functions ==================================*/
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "rb", MYNAME);
}
static void
-navilink_common_init(const char* name)
+navilink_common_init(const QString& name)
{
- if (gbser_is_serial(name)) {
- if ((serial_handle = gbser_init(name)) == NULL) {
- fatal(MYNAME ": Could not open serial port %s\n", name);
+ if (gbser_is_serial(qPrintable(name))) {
+ if ((serial_handle = gbser_init(qPrintable(name))) == NULL) {
+ fatal(MYNAME ": Could not open serial port %s\n", qPrintable(name));
}
if (gbser_set_port(serial_handle, 115200, 8, 0, 1) != gbser_OK) {
}
static void
-navilink_rd_init(const char* name)
+navilink_rd_init(const QString& name)
{
operation = READING;
navilink_common_init(name);
}
static void
-navilink_wr_init(const char* name)
+navilink_wr_init(const QString& name)
{
operation = WRITING;
navilink_common_init(name);
*******************************************************************************/
static void
-navitel_rd_init(const char* fname)
+navitel_rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
}
}
static void
-navitel_wr_init(const char* fname)
+navitel_wr_init(const QString& fname)
{
fout = gbfopen(fname, "wb", MYNAME);
}
};
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen(fname, "rb", MYNAME);
macstumbler = 0;
static Waypoint* curr_waypt;
static Waypoint* last_waypt;
static void* gbser_handle;
-static const char* posn_fname;
+static QString posn_fname;
static queue pcmpt_head;
static int without_date; /* number of created trackpoints without a valid date */
static int had_checksum;
static Waypoint* nmea_rd_posn(posn_status*);
-static void nmea_rd_posn_init(const char* fname);
+static void nmea_rd_posn_init(const QString& fname);
arglist_t nmea_args[] = {
{"snlen", &snlenopt, "Max length of waypoint name to write", "6", ARGTYPE_INT, "1", "64" },
}
static void
-nmea_rd_init(const char* fname)
+nmea_rd_init(const QString& fname)
{
curr_waypt = NULL;
last_waypt = NULL;
fatal("nmea_rd_deinit: illegal read_mode.\n");
break;
}
+
+ posn_fname.clear();
+
}
static void
-nmea_wr_init(const char* portname)
+nmea_wr_init(const QString& portname)
{
CHECK_BOOL(opt_gprmc);
CHECK_BOOL(opt_gpgga);
}
void
-nmea_rd_posn_init(const char* fname)
+nmea_rd_posn_init(const QString& fname)
{
- if ((gbser_handle = gbser_init(fname)) != NULL) {
+ if ((gbser_handle = gbser_init(qPrintable(fname))) != NULL) {
read_mode = rm_serial;
gbser_set_speed(gbser_handle, 4800);
} else {
- fatal(MYNAME ": Could not open '%s' for position tracking.\n", fname);
+ fatal(MYNAME ": Could not open '%s' for position tracking.\n", qPrintable(fname));
}
gbser_flush(gbser_handle);
continue;
}
}
- fatal(MYNAME ": No data received on %s.\n", posn_fname);
+ fatal(MYNAME ": No data received on %s.\n", qPrintable(posn_fname));
}
nmea_parse_one_line(ibuf);
if (lt != last_read_time) {
}
static void
-nmea_wr_posn_init(const char* fname)
+nmea_wr_posn_init(const QString& fname)
{
nmea_wr_init(fname);
}
/* %%% global callbacks %%% */
static void
-nmn4_rd_init(const char* fname)
+nmn4_rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
}
}
static void
-nmn4_wr_init(const char* fname)
+nmn4_wr_init(const QString& fname)
{
fout = gbfopen(fname, "wb", MYNAME);
}
}
static void
-osm_rd_init(const char* fname)
+osm_rd_init(const QString& fname)
{
wpt = NULL;
rte = NULL;
/*-----------------------------------------------------------------------------*/
static void
-osm_wr_init(const char* fname)
+osm_wr_init(const QString& fname)
{
fout = gbfopen(fname, "w", MYNAME);
#include <math.h> /* for floor */
#include <stdlib.h>
#include <stdio.h>
+#include <QtCore/QFileInfo>
#define MYNAME "OZI"
#define BADCHARS ",\r\n"
static gpsdata_type ozi_objective;
-static char* ozi_ofname = NULL;
+static QString ozi_ofname;
static void
ozi_copy_fsdata(ozi_fsdata** dest, ozi_fsdata* src)
}
static void
-ozi_openfile(char* fname)
+ozi_openfile(const QString& fname)
{
- char* c, *cx, *tmpname;
const char* ozi_extensions[] = {0, "plt", "wpt", "rte"};
- char buff[32];
/* if we're doing multi-track output, sequence the filenames like:
* mytrack.plt, mytrack-1.plt...unless we're writing to stdout.
*/
- if (0 == strcmp(fname, "-")) {
+ if (fname == "-") {
if (! file_out) {
file_out = gbfopen(fname, "wb", MYNAME);
}
return;
}
+ QString buff;
if ((track_out_count) && (ozi_objective == trkdata)) {
- sprintf(buff, "-%d", track_out_count);
+ buff = QString("-%d").arg(track_out_count);
} else {
- buff[0] = '\0';
+ buff = QString("");
}
/* remove extension and add buff + ozi's extension */
- c = strrchr(fname, '.');
- if (c && (cx = strrchr(fname, '/')) && (cx > c)) {
- c = NULL;
- }
- if (c && (cx = strrchr(fname, '\\')) && (cx > c)) {
- c = NULL;
- }
- if (c == NULL) {
- c = fname + strlen(fname);
+ QString sname(fname);
+ int suffix_len = QFileInfo(fname).suffix().length();
+ if (suffix_len > 0) {
+ /* drop the suffix and the period */
+ sname.chop(suffix_len + 1);
}
- xasprintf(&tmpname, "%*.*s%s.%s", (int)(c - fname),(int)(c - fname), fname, buff, ozi_extensions[ozi_objective]);
+
+ QString tmpname = QString("%1%2.%3").arg(sname).arg(buff).arg(ozi_extensions[ozi_objective]);
/* re-open file_out with the new filename */
if (file_out) {
file_out = gbfopen(tmpname, "wb", MYNAME);
- xfree(tmpname);
-
return;
}
}
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen(fname, "rb", MYNAME);
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
/* At this point, we have no idea whether we'll be writing waypoint,
* we're actually ready to write.
*/
- ozi_ofname = (char*)fname;
+ ozi_ofname = fname;
mkshort_handle = mkshort_new_handle();
gbfclose(file_out);
file_out = NULL;
}
- ozi_ofname = NULL;
+ ozi_ofname.clear();
mkshort_del_handle(&mkshort_handle);
}
};
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen(fname, "w", MYNAME);
mkshort_handle = mkshort_new_handle();
static gbfile* file_in, *file_out;
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen_le(fname, "wb", MYNAME);
}
};
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
xml_init(fname, gl_map, NULL);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
fatal("Writing file of type %s is not supported\n", MYNAME);
}
static gbfile* file_in, *file_out;
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "r", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen_le(fname, "w", MYNAME);
}
}
static void
-psit_rd_init(const char* fname)
+psit_rd_init(const QString& fname)
{
psit_file_in = gbfopen(fname, "r", MYNAME);
}
}
static void
-psit_wr_init(const char* fname)
+psit_wr_init(const QString& fname)
{
psit_file_out = gbfopen(fname, "w", MYNAME);
}
}
static void
-random_rd_init(const char* fname)
+random_rd_init(const QString& fname)
{
}
/* ============================================= */
static void
-raymarine_rd_init(const char* fname)
+raymarine_rd_init(const QString& fname)
{
- fin = inifile_init(fname, MYNAME);
+ fin = inifile_init(qPrintable(fname), MYNAME);
if (fin->unicode) {
cet_convert_init(CET_CHARSET_UTF8, 1);
}
}
static void
-raymarine_wr_init(const char* fname)
+raymarine_wr_init(const QString& fname)
{
fout = gbfopen(fname, "wb", MYNAME);
}
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
infile = gbfopen(fname, "rb", MYNAME);
if (split && (turns_important || turns_only)) {
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
fatal(MYNAME ":Not enough information is known about this format to write it.\n");
}
/**********************************************************************/
static void
-sbn_rd_init(const char* fname)
+sbn_rd_init(const QString& fname)
{
file_handle = gbfopen(fname, "r", MYNAME);
}
*******************************************************************************/
static void
-sbp_rd_init(const char* fname)
+sbp_rd_init(const QString& fname)
{
file_handle = gbfopen(fname, "r", MYNAME);
}
static double* polybufx;
static double* polybufy;
static double* polybufz;
-static const char* ofname;
+static QString ofname;
static int nameidx;
static int urlidx;
};
static void
-my_rd_init(const char* fname)
+my_rd_init(const QString& fname)
{
- ihandle = SHPOpen(fname, "rb");
+ ihandle = SHPOpen(qPrintable(fname), "rb");
if (ihandle == NULL) {
- fatal(MYNAME ":Cannot open shp file %s for reading\n", fname);
+ fatal(MYNAME ":Cannot open shp file %s for reading\n", qPrintable(fname));
}
- ihandledb = DBFOpen(fname, "rb");
+ ihandledb = DBFOpen(qPrintable(fname), "rb");
if (ihandledb == NULL) {
- fatal(MYNAME ":Cannot open dbf file %s for reading\n", fname);
+ fatal(MYNAME ":Cannot open dbf file %s for reading\n", qPrintable(fname));
}
if (opt_name) {
} else {
nameidx = DBFGetFieldIndex(ihandledb, opt_name);
if (nameidx == -1) {
- fatal(MYNAME ":dbf file for %s doesn't have '%s' field.\n", fname, opt_name);
+ fatal(MYNAME ":dbf file for %s doesn't have '%s' field.\n", qPrintable(fname), opt_name);
}
}
} else {
nameidx = DBFGetFieldIndex(ihandledb, "NAME");
if (nameidx == -1) {
-// fatal(MYNAME ":dbf file for %s doesn't have 'NAME' field.\n Please specify the name index with the 'name' option.\n", fname);
+// fatal(MYNAME ":dbf file for %s doesn't have 'NAME' field.\n Please specify the name index with the 'name' option.\n", qPrintable(fname));
}
}
if (opt_url) {
}
void
-my_wr_init(const char* fname)
+my_wr_init(const QString& fname)
{
ofname = fname;
}
my_wr_deinit(void)
{
SHPClose(ohandle);
+ ofname.clear();
}
void
switch (global_opts.objective) {
case wptdata:
case unknown_gpsdata:
- ohandle = SHPCreate(ofname, SHPT_POINT);
+ ohandle = SHPCreate(qPrintable(ofname), SHPT_POINT);
if (ohandle == NULL) {
fatal(MYNAME ":Cannot open %s for writing\n",
- ofname);
+ qPrintable(ofname));
}
waypt_disp_all(my_write_wpt);
break;
case trkdata:
- ohandle = SHPCreate(ofname, SHPT_ARC);
+ ohandle = SHPCreate(qPrintable(ofname), SHPT_ARC);
if (ohandle == NULL) {
fatal(MYNAME ":Cannot open %s for writing\n",
- ofname);
+ qPrintable(ofname));
}
route_disp_all(poly_init, poly_deinit, poly_point);
break;
*******************************************************************************/
static void
-skyforce_rd_init(const char* fname)
+skyforce_rd_init(const QString& fname)
{
fin = gbfopen(fname, "r", MYNAME);
}
static void
-skyforce_wr_init(const char* fname)
+skyforce_wr_init(const QString& fname)
{
fout = gbfopen(fname, "w", MYNAME);
#define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
-static char* port; /* port name */
static void* serial_handle = 0; /* IO file descriptor */
static int skytraq_baud = 0; /* detected baud rate */
static gbfile* file_handle = 0; /* file descriptor (used by skytraq-bin format) */
*******************************************************************************/
static void
-skytraq_rd_init(const char* fname)
+skytraq_rd_init(const QString& fname)
{
- port = xstrdup(fname);
- if ((serial_handle = gbser_init(fname)) == NULL) {
- fatal(MYNAME ": Can't open port '%s'\n", fname);
+ if ((serial_handle = gbser_init(qPrintable(fname))) == NULL) {
+ fatal(MYNAME ": Can't open port '%s'\n", qPrintable(fname));
}
if ((skytraq_baud = skytraq_probe()) <= 0) {
- fatal(MYNAME ": Can't find skytraq device on '%s'\n", fname);
+ fatal(MYNAME ": Can't find skytraq device on '%s'\n", qPrintable(fname));
}
}
{
gbser_deinit(serial_handle);
serial_handle = NULL;
- xfree(port);
}
static void
}
static void
-file_init(const char* fname)
+file_init(const QString& fname)
{
db(1, "Opening file...\n");
if ((file_handle = gbfopen(fname, "rb", MYNAME)) == NULL) {
- fatal(MYNAME ": Can't open file '%s'\n", fname);
+ fatal(MYNAME ": Can't open file '%s'\n", qPrintable(fname));
}
}
}
return result;
}
-static const char* mhport;
+static QString mhport;
static void
-miniHomer_rd_init(const char* fname)
+miniHomer_rd_init(const QString& fname)
{
opt_set_location=NULL; // otherwise it will lead to bus error
skytraq_rd_init(fname); // sets global var serial_handle
miniHomer_rd_deinit(void)
{
skytraq_rd_deinit();
+ mhport.clear();
}
#define SETPOI(poinum, poiname) if (opt_set_poi_##poiname ) {miniHomer_set_poi(poinum, opt_set_poi_##poiname);}
static void
/* ----------------------------------------------------------- */
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
fin = gbfopen(fname, "r", MYNAME);
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
fout = gbfopen(fname, "w", MYNAME);
short_h = mkshort_new_handle();
static void
-stmwpp_rd_init(const char* fname)
+stmwpp_rd_init(const QString& fname)
{
fin = gbfopen(fname, "rb", MYNAME);
track = NULL;
}
static void
-stmwpp_rw_init(const char* fname)
+stmwpp_rw_init(const QString& fname)
{
fout = gbfopen(fname, "wb", MYNAME);
short_h = mkshort_new_handle();
/* global callback (exported) functions */
static void
-subrip_wr_init(const char* fname)
+subrip_wr_init(const QString& fname)
{
time_t gpstime_t;
struct tm* ptm_gps;
}
static void
-tef_xml_rd_init(const char* fname)
+tef_xml_rd_init(const QString& fname)
{
wpt_tmp = NULL;
waypoints = 0;
static gbfile* fin;
static void
-teletype_rd_init(const char* fname)
+teletype_rd_init(const QString& fname)
{
char header[64];
static char* altunits = NULL;
static char* split_output = NULL;
static int waypoint_count;
-static char* output_name;
+static QString output_name;
#define MYNAME "TEXT"
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
waypoint_count = 0;
- output_name = xstrdup(fname);
+ output_name = fname;
if (!split_output) {
file_out = gbfopen(fname, "w", MYNAME);
}
gbfclose(file_out);
}
mkshort_del_handle(&mkshort_handle);
- xfree(output_name);
+ output_name.clear();
}
static void
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen(fname, "rb", MYNAME);
mkshort_handle = mkshort_new_handle();
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen(fname, "w", MYNAME);
thresh_days = strtod(oldthresh, NULL);
static short_handle mkshort_handle;
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen(fname, "w", MYNAME);
}
};
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
file_in = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen_le(fname, "wb", MYNAME);
}
}
static void
-tpg_rd_init(const char* fname)
+tpg_rd_init(const QString& fname)
{
tpg_common_init();
tpg_file_in = gbfopen_le(fname, "rb", MYNAME);
}
static void
-tpg_wr_init(const char* fname)
+tpg_wr_init(const QString& fname)
{
tpg_common_init();
tpg_file_out = gbfopen_le(fname, "wb", MYNAME);
static void
-tpo_rd_init(const char* fname)
+tpo_rd_init(const QString& fname)
{
// preprare for an attempt to deallocate memory that may or may not get allocated
}
static void
-tpo_wr_init(const char* fname)
+tpo_wr_init(const QString& fname)
{
if (doing_wpts || doing_rtes) {
fatal(MYNAME ": this file format only supports tracks, not waypoints or routes.\n");
}
static void
-unicsv_rd_init(const char* fname)
+unicsv_rd_init(const QString& fname)
{
char* c;
unicsv_altscale = 1.0;
static void
-unicsv_wr_init(const char* filename)
+unicsv_wr_init(const QString& filename)
{
fout = gbfopen(filename, "wb", MYNAME);
#include <stdlib.h>
#include <stdarg.h> // for va_copy
#include <time.h>
+#include <QtCore/QFileInfo>
// First test Apple's clever macro that's really a runtime test so
// that our universal binaries work right.
return result;
}
-const char* get_filename(const char* fname)
+const QString get_filename(const QString& fname)
{
- const char* res;
- const char* cb;
- const char* cs;
-
- cb = strrchr(fname, '\\');
- cs = strrchr(fname, '/');
-
- if (cb == NULL) {
- res = cs;
- } else if (cs == NULL) {
- res = cb;
- } else {
- res = (cs > cb) ? cs : cb;
- }
-
- return (res == NULL) ? (char*) fname : ++res;
+ return QFileInfo(fname).fileName();
}
/* bit manipulation functions */
}
static void
-v900_rd_init(const char* fname)
+v900_rd_init(const QString& fname)
{
- v900_log("%s(%s)\n",__func__,fname);
+ v900_log("%s(%s)\n",__func__,qPrintable(fname));
/* note: file is opened in binary mode, since lines end with \r\n, and in windows text mode
that will be translated to a single \n, making the line len one character shorter than
on linux machines.
*/
- fin = fopen(fname,"rb");
+ fin = fopen(qPrintable(fname),"rb");
if (!fin) {
- fatal("v900: could not open '%s'.\n", fname);
+ fatal("v900: could not open '%s'.\n", qPrintable(fname));
}
}
};
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
file_out = gbfopen(fname, "w", MYNAME);
mkshort_handle = mkshort_new_handle();
*******************************************************************************/
static void
-vidaone_rd_init(const char* fname)
+vidaone_rd_init(const QString& fname)
{
vidaone_ver = atoi(vidaone_opt_ver);
fin = gbfopen(fname, "rb", MYNAME);
}
static void
-vidaone_wr_init(const char* fname)
+vidaone_wr_init(const QString& fname)
{
vidaone_ver = atoi(vidaone_opt_ver);
fout = gbfopen(fname, "wb", MYNAME);
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
infile = gbfopen_le(fname, "rb", MYNAME);
}
}
static void
-wr_init(const char* fname)
+wr_init(const QString& fname)
{
warning(MYNAME " write: format is experimental and may crash Vito Navigator II.\n");
ofs = gbfopen_le(fname, "wb", MYNAME);
static const int vitovtt_microsecondscale = 30;
static void
-rd_init(const char* fname)
+rd_init(const QString& fname)
{
infile = gbfopen_le(fname, "rb", MYNAME);
}
*******************************************************************************/
static void
-vpl_rd_init(const char* fname)
+vpl_rd_init(const QString& fname)
{
vpl_file_in = gbfopen(fname, "r", MYNAME);
}
}
static void
-vpl_wr_init(const char* fname)
+vpl_wr_init(const QString& fname)
{
fatal("Writing file of type %s is not support\n", MYNAME);
}
}
-static void rd_init(const char* fname)
+static void rd_init(const QString& fname)
{
- port = xstrdup(fname);
+ port = xstrdup(qPrintable(fname));
db(1, "Opening port...\n");
if ((fd = gbser_init(port)) == NULL) {
return 1;
}
-static void file_init(const char* fname)
+static void file_init(const QString& fname)
{
db(1, "Opening file...\n");
- if ((fl = fopen(fname, "rb")) == NULL) {
- fatal(MYNAME ": Can't open file '%s'\n", fname);
+ if ((fl = fopen(qPrintable(fname), "rb")) == NULL) {
+ fatal(MYNAME ": Can't open file '%s'\n", qPrintable(fname));
}
}
}
void
-wfff_xml_rd_init(const char* fname)
+wfff_xml_rd_init(const QString& fname)
{
tosscount = 0;
static gbfile* fin;
static void
-wintec_tes_rd_init(const char* fname)
+wintec_tes_rd_init(const QString& fname)
{
fin = gbfopen(fname, "r", MYNAME);
}
static void
-xcsv_rd_init(const char* fname)
+xcsv_rd_init(const QString& fname)
{
/*
if ((xcsv_file.datatype == 0) || (xcsv_file.datatype == wptdata)) {
if (global_opts.masked_objective & (TRKDATAMASK|RTEDATAMASK)) {
- warning(MYNAME " attempt to read %s as a track or route, but this format only supports waypoints on read. Reading as waypoints instead.\n", fname);
+ warning(MYNAME " attempt to read %s as a track or route, but this format only supports waypoints on read. Reading as waypoints instead.\n", qPrintable(fname));
}
}
}
static void
-xcsv_wr_init(const char* fname)
+xcsv_wr_init(const QString& fname)
{
/* if we don't have an internal style defined, we need to
* read it from a user-supplied style file, or die trying.
}
xcsv_file.xcsvfp = gbfopen(fname, "w", MYNAME);
- xcsv_file.fname = (char*)fname;
+ xcsv_file.fname = fname;
/* set mkshort options from the command line */
if (global_opts.synthesize_shortnames) {
}
static void
-xcsv_wr_position_init(const char* fname)
+xcsv_wr_position_init(const QString& fname)
{
xcsv_wr_init(fname);
}
static xg_tag_mapping* xg_tag_tbl;
static QSet<QString> xg_ignore_taglist;
-static const char* rd_fname;
+static QString rd_fname;
static QByteArray reader_data;
static const char* xg_encoding;
static QTextCodec* utf8_codec = QTextCodec::codecForName("UTF-8");
}
void
-xml_init(const char* fname, xg_tag_mapping* tbl, const char* encoding)
+xml_init(const QString& fname, xg_tag_mapping* tbl, const char* encoding)
{
rd_fname = fname;
xg_tag_tbl = tbl;
xml_deinit(void)
{
reader_data.clear();
- rd_fname = NULL;
+ rd_fname.clear();
xg_tag_tbl = NULL;
xg_encoding = NULL;
codec = utf8_codec;
extern const char* xhtml_entities;
void xml_ignore_tags(const char** taglist);
-void xml_init(const char* fname, xg_tag_mapping* tbl,const char* encoding);
+void xml_init(const QString& fname, xg_tag_mapping* tbl,const char* encoding);
void xml_init_offset(const char* fname, xg_tag_mapping* tbl,
const char* encoding, gbsize_t offset);
void xml_read(void);
GPS_Math_Swiss_EN_To_WGS84(x, y, &wpt->latitude, &wpt->longitude);
}
-static void xol_rd_init(const char* fname) {
+static void xol_rd_init(const QString& fname) {
trk = NULL;
wpt = NULL;
waypt_add_to_bounds(&all_bounds, wpt);
}
-static void xol_wr_init(const char* fname) {
+static void xol_wr_init(const QString& fname) {
oqfile = new gpsbabel::File(fname);
oqfile->open(QIODevice::WriteOnly | QIODevice::Text);
};
static void
-yahoo_rd_init(const char* fname)
+yahoo_rd_init(const QString& fname)
{
xml_init(fname, gl_map, NULL);
}
}
static void
-yahoo_wr_init(const char* fname)
+yahoo_wr_init(const QString& fname)
{
fatal("Writing file of type %s is not supported\n", MYNAME);
}
projects / gpsbabel.git / commitdiff